const express = require('express')
const cors = require('cors')
const morgan = require('morgan')
const helmet = require('helmet')
const compression = require('compression')
const { Sequelize } = require('sequelize')
const logger = require('./utils/logger')
const fs = require('fs')
const path = require('path')
const net = require('net')
require('dotenv').config()

// 创建Express应用
const app = express()

// 中间件
app.use(cors())
app.use(helmet())
app.use(compression())
app.use(express.json())
app.use(express.urlencoded({ extended: true }))
app.use(morgan('combined', { stream: { write: message => logger.info(message.trim()) } }))

// 简化的请求日志中间件（仅在开发环境启用）
if (process.env.NODE_ENV === 'development') {
  app.use((req, res, next) => {
    logger.info(`${req.method} ${req.path}`)
    next()
  })
}

// 路由
app.use('/api/auth', require('./routes/auth'))
app.use('/api/users', require('./routes/users'))
app.use('/api/products', require('./routes/products'))
app.use('/api/orders', require('./routes/orders'))
app.use('/api/points', require('./routes/points'))
app.use('/api/files', require('./routes/files'))
app.use('/api/ads', require('./routes/ads'))
app.use('/api/invitations', require('./routes/invitations'))
app.use('/api/members', require('./routes/members'))
app.use('/api/messages', require('./routes/messages'))
app.use('/api/print', require('./routes/print'))
app.use('/api/rewards', require('./routes/rewards'))
app.use('/api/sync', require('./routes/sync'))
app.use('/api/admin', require('./routes/admin'))
app.use('/api/analytics', require('./routes/analytics'))
app.use('/api/permissions', require('./routes/permissions'))

// 健康检查
app.get('/health', (req, res) => {
  res.status(200).json({ status: 'ok', timestamp: new Date() })
})

// 404处理
app.use((req, res) => {
  res.status(404).json({
    success: false,
    message: '接口不存在'
  })
})

// 错误处理中间件
app.use(require('./middleware/errorHandler'))

// 检查端口是否可用
function isPortAvailable(port) {
  return new Promise((resolve) => {
    const server = net.createServer()
    server.listen(port, () => {
      server.once('close', () => {
        resolve(true)
      })
      server.close()
    })
    server.on('error', () => {
      resolve(false)
    })
  })
}

// 查找可用端口
async function findAvailablePort(startPort) {
  let port = startPort
  while (port < startPort + 100) {
    if (await isPortAvailable(port)) {
      return port
    }
    port++
  }
  throw new Error('无法找到可用端口')
}

// 数据库初始化
async function initializeDatabase() {
  try {
    const sequelize = require('./config/database')
    
    // 测试数据库连接
    await sequelize.authenticate()
    logger.info('数据库连接成功')
    
    try {
      // 尝试正常同步
      await sequelize.sync({ force: false })
      logger.info('数据库模型同步完成')
    } catch (syncError) {
      if (syncError.message.includes('Too many keys specified')) {
        logger.warn('检测到索引过多问题，尝试修复orders表...')
        
        try {
          // 使用修复脚本清理索引
          const fixOrdersTable = require('./scripts/fixOrdersTable')
          await fixOrdersTable()
          
          // 重新尝试同步
          await sequelize.sync({ force: false })
          logger.info('数据库模型同步完成')
        } catch (fixError) {
          logger.error('修复orders表失败，尝试重建...')
          
          // 如果修复失败，重建表
          const { Order } = require('./models')
          await Order.drop()
          logger.info('已删除orders表')
          
          await Order.sync({ force: true })
          logger.info('已重建orders表')
          
          await sequelize.sync({ force: false })
          logger.info('数据库模型同步完成')
        }
      } else {
        throw syncError
      }
    }
    
    // 加载初始数据
    await loadInitialData()
    
    // 创建示例产品数据
    try {
      const { seedProducts } = require('./scripts/seedProducts')
      await seedProducts()
    } catch (seedError) {
      if (seedError.message.includes("Unknown column 'image_url'") || 
          seedError.message.includes("doesn't exist")) {
        logger.warn('检测到products表结构问题，尝试修复...')
        
        try {
          // 使用alter同步Product表结构
          const { Product } = require('./models')
          await Product.sync({ alter: true })
          logger.info('products表结构修复完成')
          
          // 重新尝试创建示例数据
          await seedProducts()
        } catch (fixError) {
          logger.error('修复products表失败，重建表...')
          
          // 如果修复失败，重建表
          const { Product } = require('./models')
          await Product.sync({ force: true })
          logger.info('已重建products表')
          
          // 重新创建示例数据
          await seedProducts()
        }
      } else {
        throw seedError
      }
    }
    
  } catch (error) {
    logger.error('数据库初始化失败:', error)
    
    if (error.name === 'SequelizeConnectionError') {
      if (error.original?.code === 'ECONNREFUSED') {
        logger.error('无法连接到MySQL服务器，请确保MySQL正在运行')
        logger.error('解决方案：')
        logger.error('1. 如果使用XAMPP/WAMP，请启动MySQL服务')
        logger.error('2. 如果使用Docker，请运行: docker-compose up -d mysql')
        logger.error('3. 检查.env文件中的数据库配置是否正确')
      } else if (error.original?.code === 'ER_BAD_DB_ERROR') {
        logger.error(`数据库 '${process.env.DB_NAME}' 不存在`)
        logger.error('解决方案：')
        logger.error('1. 运行: node src/scripts/createDatabase.js')
        logger.error('2. 或手动创建数据库: CREATE DATABASE ' + process.env.DB_NAME)
      }
    }
    
    throw error
  }
}

// 加载初始数据
async function loadInitialData() {
  try {
    const { User } = require('./models')
    
    // 检查是否已有管理员用户
    const adminExists = await User.findOne({ where: { phone: 'admin' } })
    if (!adminExists) {
      // 创建管理员用户
      await User.create({
        phone: 'admin',
        password: 'admin123',
        nickname: '系统管理员',
        role: 'admin',
        status: 1,
        invitationCode: 'ADMIN01',
        points: 0
      })
      logger.info('创建管理员用户成功')
    } else {
      // 如果用户存在但role不是admin，更新role
      if (adminExists.role !== 'admin') {
        await adminExists.update({ role: 'admin' })
        logger.info('更新现有用户为管理员')
      }
    }
    
    // 检查是否已有测试用户
    const testUserExists = await User.findOne({ where: { phone: '13800138000' } })
    if (!testUserExists) {
      // 创建测试用户
      await User.create({
        phone: '13800138000',
        password: '123456',
        nickname: '测试用户',
        role: 'user',
        status: 1,
        points: 100
      })
      logger.info('创建测试用户成功')
    }
    
    logger.info('初始数据加载完成')
  } catch (error) {
    logger.error('加载初始数据失败:', error)
    throw error
  }
}

// 启动服务器
async function startServer() {
  try {
    let PORT = process.env.PORT || 3000
    
    // 检查端口是否可用
    if (!(await isPortAvailable(PORT))) {
      logger.warn(`端口 ${PORT} 已被占用，正在查找可用端口...`)
      PORT = await findAvailablePort(PORT + 1)
    }
    
    // 启动服务器
    app.listen(PORT, async () => {
      logger.info(`服务器已启动，监听端口: ${PORT}`)
      
      try {
        // 初始化数据库和加载初始数据
        await initializeDatabase()
        
        // 启动定时任务
        const OrderTimeoutJob = require('./jobs/orderTimeoutJob')
        OrderTimeoutJob.start()
      } catch (error) {
        logger.error('服务器初始化失败:', error)
      }
    })
  } catch (error) {
    logger.error('启动服务器失败:', error)
  }
}

// 启动服务器
startServer()

// 处理未捕获的异常
process.on('uncaughtException', (error) => {
  logger.error('未捕获的异常:', error)
})

// 处理未处理的Promise拒绝
process.on('unhandledRejection', (reason, promise) => {
  logger.error('未处理的Promise拒绝:', reason)
})

module.exports = app